package com.ftg.learn.chapter17.linked;

import javafx.beans.binding.BooleanExpression;

/**
 * @author KangJx
 * @date 2021/8/4
 */
public class MyLinked {

    /**
     * 成员内部类
     */
    class Node {

        /**
         * 数据项，用来存储真实元素的位置
         */
        public int val;

        /**
         * 下一元素指针
         */
        public Node next;

        /**
         * 构造方法用来完成创建一个带数据的节点
         * @param val
         */
        public Node(int val) {
            this.val = val;
        }
    }

    /**
     * 头节点
     */
    private Node head;

    /**
     * 最后一个节点
     */
    private Node last;

    private Node pointNode;

    /**
     * 创建元素的
     * @param val
     */
    public MyLinked(int val){
        Node curr = new Node(val);
        head = curr;
        last = curr;
    }

    /**
     * 默认情况只有一个头节点
     */
    public MyLinked(){
    }

    /**
     * 编写一个添加方法,追加
     *  在单链表最后一个元素的后面 next 添加一个新节点
     *  他说：哥们速度太慢了,怎么办?
     *  是不是就是为了找到最后一个元素,追加就是为了找到最后一个元素.next = new Node(23);
     */
    public void add(int val){
        //val 把放到head后面吗？
        //应该从头节点向next发起遍历 ，直到某一个节点的next为null的时候
        Node curr = new Node(val);
        //循环
        ///我想拿到最后一个节点
        Node temp = head;
        //不等于null还有元素
       if(temp != null){
           while(null != temp.next){
               temp = temp.next;
           }
           //递归  1. 这个方法用递归尝试改写一下?
           temp.next = curr;
       }else{
           head = curr;
       }
    }

    /**
     * 为链表在最后添加一个元素的方法
     * @param val
     */
    public void append(int val){
        //val 把放到head后面吗？
        //应该从头节点向next发起遍历 ，直到某一个节点的next为null的时候
        Node curr = new Node(val);
        if(null == head){
            head = curr;
            last = head;
            pointNode = head;
        }else{
            last.next = curr;
            last = last.next;
        }

    }

    /**
     * 判断pointNode是否有下一元素
     * @return
     */
    public boolean hasNext(){
        return pointNode == null ? false:true;
    }

    /**
     * 大家来补全，求现在有多少个元素
     * @return
     */
    public int size(){
        if(head.next == null){
            return 0;
        }
        int size = 0;
        Node curr = head;
        while (curr != null){
            size++;
            curr = curr.next;
        }
        System.out.print(size);
        return size;
    }

    /**
     * 插入方法
     * @param index  下标
     * @param val    数据
     * @return
     */
    public boolean insert(int index, int val){

//        Node curr = new Node(val);
//        point = head;
//        if (index == 0) {
//            curr.next = head;
//            head = curr;
//        } else {
//            int i = 0;
//            while (i < index - 1) {
//                point = point.next;
//                i++;
//            }
//            curr.next = point.next;
//            point.next = curr;
//        }
//        point = head;
        return true;
    }

    /**
     * 删除第三个位置的元素
     * @param index
     * @return
     */
    public boolean remove(int index){
        pointNode = head;
        if(index == 0){
            head = head.next;
        }else {
            int x = 0;
            while(x < index - 1){
                pointNode = pointNode.next;
                x++;
            }
            pointNode.next = pointNode.next.next;
        }
        pointNode = head;
        return true;
    }

    /**
     * 取到当前节点的val值，并将pointNode下移一位
     * @return
     */
    public int next(){
        int val = pointNode.val;
        pointNode = pointNode.next;
        return val;
    }

    /**
     * 头节点的值
     * @return int
     */
    public int getHead(){
        return this.head.val;
    }

    /**
     * 尾节点的值
     * @return int
     */
    public int getLast(){
        return this.last.val;
    }

}
